home *** CD-ROM | disk | FTP | other *** search
/ C/C++ Interactive Reference Guide / C-C++ Interactive Reference Guide.iso / c_ref / csource5 / 355_01 / slk1.exe / SHERLOCK / SLTEST.C < prev    next >
Encoding:
C/C++ Source or Header  |  1991-06-09  |  5.6 KB  |  352 lines
  1. /*
  2.     Test file for all sherlock macros.
  3.  
  4.     source:  sl.tst
  5.     started: June 2, 1988
  6.     version:
  7.         February 14, 1989
  8.         March 24, 1989
  9.         April 19, 1989
  10.         June 30, 1989 include <stdio.h> added.
  11. */
  12.  
  13. #undef SHERLOCK
  14. #define SHERLOCK 1
  15.  
  16. #ifdef PREFERRED
  17. #include "sl.h"
  18. #else
  19. #include "sl1.h"
  20. #endif
  21.  
  22. #include <stdio.h>
  23.  
  24. struct struct1 {int a;};
  25. struct struct1 struct1_var;
  26.  
  27. typedef int bool;
  28. typedef enum {red, blue, green} en_test;
  29.  
  30. bool    bool_test();
  31. char    char_test();
  32. double    double_test();
  33. en_test    enum_test();
  34. float    float_test();
  35. int    int_test();
  36. long    long_test();
  37. void *    ptr_test();
  38. char *    str_test();
  39. unsigned int
  40.     uint_test();
  41. unsigned long
  42.     ulong_test();
  43. void    void_test();
  44. void    name_test();
  45. void    off_test();
  46. void    on_off_test();
  47. void    ptrace_test();
  48. void    stat_test();
  49. void    tick_test();
  50. void    trace_test();
  51. void    time_test();
  52. void    time2_test();
  53. void    sppo_test();
  54. struct struct1 struct_test();
  55. struct struct1 s1var;
  56.  
  57. void f1(void), f2(void), g1(void), g2(void);
  58.  
  59. main(argc, argv)
  60. int argc;
  61. char **argv;
  62. {
  63.     SL_INIT();
  64.     SL_PARSE(argc, argv, "++", "--");
  65.  
  66.     ENTER_TRACE("main", printf("argc: %d\n", argc));
  67.  
  68.     STAT("main_stat_test");
  69.  
  70. #ifdef PREFERRED
  71.     printf("\nsltest ");
  72. #else
  73.     printf("\nsl--1--test ");
  74. #endif
  75.  
  76.     printf("June 30, 1989\n\n");
  77.  
  78.     bool_test();
  79.     char_test();
  80.     double_test();
  81.     enum_test();
  82.     float_test();
  83.     int_test();
  84.     long_test();
  85.     ptr_test();
  86.     str_test();
  87.     uint_test();
  88.     ulong_test();
  89.     void_test();
  90.     sppo_test();
  91.  
  92.     name_test();
  93.     off_test();
  94.     on_off_test();
  95.     ptrace_test();
  96.     stat_test();
  97.     tick_test();
  98.     trace_test();
  99.     s1var= struct_test();
  100.  
  101.     TRACEP("dump", SL_DUMP());
  102.  
  103.     TRACEPN("dump", SL_CLEAR(); printf("\n"));
  104.     time_test();
  105.     TRACEP("dump", SL_DUMP());
  106.  
  107.     TICK("BAD_TRACEPOINT_NAME!");
  108.     LEAVE("main");
  109. }
  110.  
  111. bool bool_test()
  112. {
  113.     ENTER("bool_test");
  114.     sl_bout(1);
  115.     printf("\nshould return %s\n", sl_sbout(1));
  116.     RETURN_BOOL("bool_test",1);
  117. }
  118.  
  119. char char_test()
  120. {
  121.     TICKB("char_test");
  122.     sl_cout('A');
  123.     printf("\nshould return A\n");
  124.     RETURN_CHAR("char_test", 'A');
  125. }
  126.  
  127. double double_test()
  128. {
  129.     TICKB("double_test");
  130.     sl_dout(0.2);
  131.     printf("\nshould return 0.2\n");
  132.     RETURN_DOUBLE("double_test", (double) 0.2);
  133. }
  134.  
  135. en_test enum_test()
  136. {
  137.     TICKB("enum_test");
  138.     sl_iout((int)blue);
  139.     printf("\nshould return blue in {red, blue, green}\n");
  140.     RETURN_INT("enum_test", blue);
  141. }
  142.  
  143. float float_test()
  144. {
  145.     TICKB("float_test");
  146.     sl_fout(0.1);
  147.     printf("\nshould return 0.1\n");
  148.     RETURN_FLOAT("float_test", 0.1);
  149. }
  150.  
  151. int int_test()
  152. {
  153.     TICKB("int_test");
  154.     sl_iout(10);
  155.     printf("\nshould return 10\n");
  156.     RETURN_INT("int_test", 10);
  157. }
  158.  
  159. long long_test()
  160. {
  161.     TICKB("long_test");
  162.     sl_lout(20L);
  163.     printf("\nshould return 20L\n");
  164.     RETURN_LONG("long_test", 20L);
  165. }
  166.  
  167. void * ptr_test()
  168. {
  169.     int a;
  170.  
  171.     TICKB("ptr_test");
  172.     sl_pout(&a);
  173.     printf("\nshould return %p\n", &a);
  174.     RETURN_PTR("ptr_test", &a);
  175. }
  176.  
  177. char * str_test()
  178. {
  179.     TICKB("str_test");
  180.     sl_sout("abc");
  181.     printf("\nshould return \"abc\"\n");
  182.     RETURN_STRING("str_test", "abc");
  183. }
  184.  
  185. unsigned int uint_test()
  186. {
  187.     TICKB("uint_test");
  188.     sl_uiout(1000);
  189.     printf("\nshould return 1000 unsigned long\n");
  190.     RETURN_UINT("uint_test", 1000);
  191. }
  192.  
  193. unsigned long ulong_test()
  194. {
  195.     TICKB("ulong_test");
  196.     sl_ulout(2000L);
  197.     printf("\nshould return 2000 unsigned long\n");
  198.     RETURN_ULONG("ulong_test", 2000L);
  199. }
  200.  
  201. void void_test()
  202. {
  203.     TICKB("void_test");
  204.     RETURN_VOID("void_test");
  205. }
  206.  
  207. void trace_test()
  208. {
  209.     TRACEB("trace_test", printf("TRACEB\n"));
  210.     TRACE("trace_test",  printf("TRACE\n"));
  211.     TRACEN("trace_test", printf("TRACEN1\n"));
  212.     TRACEN("trace_test", printf("TRACEN2\n"));
  213.     TRACEX("trace_test", printf("TRACEX\n"));
  214. }
  215.  
  216. void ptrace_test()
  217. {
  218.     TRACEPB("tracep_test", printf("TRACEPB\n"));
  219.     TRACEP("tracep_test",  printf("TRACEP\n"));
  220.     TRACEPN("tracep_test", printf("TRACEPN1\n"));
  221.     TRACEPN("tracep_test", printf("TRACEPN2\n"));
  222.     TRACEPX("tracep_test", printf("TRACEPX\n"));
  223. }
  224.  
  225. void name_test()
  226. {
  227.     SL_NAME(name,"name_test");
  228.     printf("tracepoint name should be \"name_test\"\n");
  229.     TICKB(name);
  230.     TICKX(name);
  231. }
  232.  
  233. void off_test()
  234. {
  235.     TICKB("off_test");
  236.     SL_OFF("off_test*");
  237.     TICK("off_test_off");
  238.     SL_ON("off_test*");
  239.     TICK("off_test_on");
  240.     TICKX("off_test");
  241. }
  242.  
  243. void on_off_test()
  244. {
  245.     printf("on_off_test begins...\n");
  246.     SL_ON("*");
  247.     f1();
  248.     f2();
  249.     g1();
  250.     g2();
  251.     SL_OFF("f*");
  252.     f1();
  253.     f2();
  254.     g1();
  255.     g2();
  256.     printf("on_off_test ends...\n");
  257. }
  258.  
  259. void f1(void)
  260. {
  261.     TICKB("f1");
  262.     TICKX("f1");
  263. }
  264.  
  265. void f2(void)
  266. {
  267.     TICKB("f2");
  268.     TICKX("f2");
  269. }
  270.  
  271. void g1(void)
  272. {
  273.     TICKB("g1");
  274.     TICKX("g1");
  275. }
  276.  
  277. void g2(void)
  278. {
  279.     TICKB("g2");
  280.     TICKX("g2");
  281. }
  282.  
  283. void stat_test()
  284. {
  285.     STAT("stat_test");
  286.     STATB("stat_test");
  287.     STATX("stat_test");    /* This will bump t_xtrace */
  288. }
  289.  
  290. void tick_test()
  291. {
  292.     TICK("tick_test");
  293.     TICKB("tick_test");
  294.     TICKN("tick_test");
  295.     TICKX("tick_test");
  296. }
  297.  
  298. /*
  299.     These two tests are intended to discover something about
  300.     timing statistics.
  301. */
  302. void time_test()
  303. {
  304.     int i, j;
  305.  
  306.     STATB("time_test");
  307.  
  308.     j = 0;
  309.     for (i = 0; i < 10000; i++) {
  310.         j = j + 1;
  311.     }
  312.  
  313.     time2_test();
  314.  
  315.     STATX("time_test");
  316. }
  317.  
  318. void time2_test()
  319. {
  320.     int i, j;
  321.  
  322.     STATB("time2_test");
  323.  
  324.     j = 0;
  325.     for (i = 0; i < 20000; i++) {
  326.         j = j + 1;
  327.     }
  328.     STATX("time2_test");
  329. }
  330.  
  331. /*
  332.     Test the routines generated by the SPP -o option.
  333. */
  334. void sppo_test(void)
  335. {
  336.     printf("Test of SPP -o routines: ");
  337.     sl_lpout();
  338.     sl_sout("arg1");
  339.     sl_csout();
  340.     sl_sout("arg2");
  341.     sl_rpout();
  342. }
  343.  
  344. /*
  345.     Test functions returning a struct, not pointer to struct.
  346. */
  347. struct struct1 struct_test(void)
  348. {
  349.     printf(" struct1_var: %p\n", struct1_var);
  350.     printf("&struct1_var: %p\n", &struct1_var);
  351. }
  352.